/**
 * @author WGG
 * @create 2023-05-27 16:23
 */
public class Test2 {
    /**
     * 线程的常用方法
     */

//    static boolean flag = true;
    static volatile boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
//        //1.获取当前main线程的线程名称 状态
//        Thread thread = Thread.currentThread();
//        System.out.println("获取当前线程："+thread);
//        String name = thread.getName();
//        System.out.println("当前main线程的名称"+name);
//        //2.创建一个线程并给当前线程设置名称
//        Thread t1 = new Thread(()->{
//            System.out.println(Thread.currentThread().getName());
//        });
//        System.out.println(t1.getName());
//        t1.setName("模块-功能-计数器");
//        t1.start();
//        System.out.println(t1.getName());

//        //3.设置线程的优先级
//        Thread t1 = new Thread(()->{
//            for (int i = 0; i < 1000; i++) {
//                System.out.println(Thread.currentThread().getName()+":::::"+i);
//            }
//        },"t1");
//        Thread t2 = new Thread(()->{
//            for (int i = 0; i < 1000; i++) {
//                System.out.println(Thread.currentThread().getName()+":::::"+i);
//            }
//        },"t2");
//        System.out.println(t1);
//        System.out.println(t2);
//        //线程的优先级从 低到高 1-10
//        t1.setPriority(10);
//        t2.setPriority(1);
//        t2.start();
//        t1.start();

//        //4.线程让步
//            // hread.yield()方法只能保证当前线程 让出CPU执行权，
//            // 当CPU要执行下一个线程的时候
//            // 有可能重新执行到当前线程
//        Thread t1 = new Thread(() -> {
//            for (int i = 0; i < 100; i++) {
//                System.out.println(Thread.currentThread().getName() + i);
//                if (i == 5) {
//                    Thread.yield();
//                }
//            }
//        }, "test-线程让步-计数器1：");
//        Thread t2 = new Thread(() -> {
//            for (int i = 0; i < 100; i++) {
//                System.out.println(Thread.currentThread().getName() + i);
//            }
//        }, "test-线程让步-计数器2：");
//        t1.start();
//        t2.start();

        //5.线程休眠
//        Thread t1 = new Thread(()->{
//            for (int i = 0; i < 100; i++) {
//                System.out.println(Thread.currentThread().getName()+i);
//                if (i==5){
//                    try {
//                        Thread.sleep(5000);
//                    } catch (InterruptedException e) {
//                        throw new RuntimeException(e);
//                    }
//                }
//            }
//        }, "test-线程休眠-计数器1：");
//        Thread t2 = new Thread(()->{
//            for (int i = 0; i < 100; i++) {
//                System.out.println(Thread.currentThread().getName()+i);
//            }
//        }, "test-线程休眠-计数器2：");
//        t1.start();
//        t2.start();

//        //6.线程强占  非静态方法join() 哪个线程调用 哪个线程被挂起
//        Thread t1 = new Thread(()->{
//            for (int i = 0; i < 1000; i++) {
//                System.out.println(Thread.currentThread().getName()+i);
//                    try {
//                        Thread.sleep(1000);
//                    } catch (InterruptedException e) {
//                        throw new RuntimeException(e);
//                    }
//            }
//        }, "test-线程休眠-计数器1：");
//        Thread t2 = new Thread(()->{
//            for (int i = 0; i < 1000; i++) {
//                System.out.println(Thread.currentThread().getName()+i);
//                try {
//                    Thread.sleep(1000);
//                } catch (InterruptedException e) {
//                    throw new RuntimeException(e);
//                }
//            }
//        }, "test-线程休眠-计数器2：");
//        t1.start();
//        t2.start();
//        for (int i = 0; i < 1000; i++) {
//            System.out.println(Thread.currentThread().getName()+i);
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                throw new RuntimeException(e);
//            }
//            if (i==1){
////                t1.join();// 当前是在main 线程中调用 所以main线程会 等待线程1执行完毕
//        t1.join(5000);//当前是在main 线程中调用 所以main线程会 等待线程1执行5秒
//            }
//        }

//        //7.守护线程 线程默认都是 非守护线程
////        Thread.currentThread().setDaemon(true);//当线程是守护线程时 jvm会被自动关闭
//        Thread t = new Thread(() -> {
//            for (int i = 0; i < 1000; i++) {
//                System.out.println(Thread.currentThread().getName() + i);
//                try {
//                    Thread.sleep(1000);
//                } catch (InterruptedException e) {
//                    throw new RuntimeException(e);
//                }
//            }
//        }, "test-线程休眠-计数器：");
//        t.setDaemon(true);
//        t.start();

//        //8.线程的等待和唤醒
//        Thread t1 = new Thread(() -> {
//            sync();
//        }, "线程1：");
//        Thread t2 = new Thread(() -> {
//           sync();
//        }, "线程2：");
//        t1.start();
//        t2.start();
//        Thread.sleep(12000);
//        synchronized (Test2.class){
//            Test2.class.notifyAll();
//        }

        //9.停止线程
            //1、使用 stop 直接停止 （不用）
            //2、使用 共享变量的方式
//        // 在第一个示例中
//        Thread t1 = new Thread(() -> {
//            while (flag){
//                //volatile关键字能够保证变量在多线程中的可见性，即每个线程都看到的是同一个值，而不是自己线程缓存中的副本。
//                // 在第一个示例中，由于while循环中没有任何同步机制，flag的值可能存在不一致的情况，
//                // 如果不使用volatile关键字，有可能某个线程永远不会看到flag值被修改的情况，
//                // 造成一直循环下去，从而无法执行“任务结束”的语句。
//            }
//            System.out.println("任务结束");
//        },"t1");
//        t1.start();
//        Thread.sleep(500);
//        flag=false;
//        //而在第二个示例中
//        Thread t2 = new Thread(() -> {
//            while (flag){
//                //而在第二个示例中，线程t1被阻塞了1秒钟，每次循环都会重新读取flag的值，
//                // 此时即使没有使用volatile关键字，也能够保证能够看到flag的最新值。
//                // 因为线程在阻塞期间会将自己的缓存刷新到主存中，而在第二个示例中flag的修改也是在主线程中完成的，
//                // 因此线程t1每次读取flag时都会看到最新的值。
//                try {
//                    Thread.sleep(1000);
//                } catch (InterruptedException e) {
//                    throw new RuntimeException(e);
//                }
//                System.out.println("我是 t1");
//            }
//            System.out.println("任务结束");
//        },"t2");
//        t1.start();
//        Thread.sleep(500);
//        flag=false;
        //3、使用 interrupt 的方式
        //查看当前标记位的状态
        System.out.println(Thread.currentThread().isInterrupted());
        //修改状态
        Thread.currentThread().interrupt();
        //查看，并归位
        System.out.println(Thread.interrupted());
        //查看，并归位
        System.out.println(Thread.interrupted());

    }

    public static synchronized void sync() {
        for (int i = 0; i < 10; i++) {
            if (i==5){
                try {
                    Test2.class.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName()+"："+i);
        }
    }



}
